<?php

class Archivo {
//<editor-fold defaultstate="collapsed" desc="Constantes">
  const NOMBRE_ENTIDAD = "Archivo";
  const SESION_UPLOAD = "ArchivoUpload";
  const RUTA_REPOSITORIO = "[repositorio]";
  const SIN_ENTIDAD = "Sin Asociar";
  //tipos de archivos
  const TIPO_IMAGEN = "image";
  const TIPO_AUDIO = "audio";
  const TIPO_VIDEO = "video";
  const TIPO_TEXTO = "text";
  const TIPO_APLICACION = "application";
  const TIPO_OFFICE = "office";
  const TIPO_ZIP = "zip";
  const TIPO_OTRO = "others";
  const TIPO_DESCONOCIDO = "unknow";
  //colores tamaño
  const TAMANO_ENTIDAD_VERDE = 0;
  const TAMANO_ENTIDAD_AMARILLO = 104857600;
  const TAMANO_ENTIDAD_ROJO = 314572800;
  const TAMANO_ARCHIVO_VERDE = 0;
  const TAMANO_ARCHIVO_AMARILLO = 2097152;
  const TAMANO_ARCHIVO_ROJO = 5242880;

//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Campos">
  private $_id;
  private $_nombre;
  private $_extension;
  private $_contentType;
  private $_tamano;
  private $_fechaCreacion;
  private $_idUsuario;
  private $_existe;
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Propiedades">
  public function getId() { return $this->_id; }
  public function setId($value) { $this->_id = $value; }

  public function getNombre() { return $this->_nombre; }
  public function setNombre($value) { $this->_nombre = $value; }

  public function getExtension() { return $this->_extension; }
  public function setExtension($value) { $this->_extension = $value; }

  public function getContentType() { return $this->_contentType; }
  public function setContentType($value) { $this->_contentType = $value; }

  public function getTamano() { return $this->_tamano; }
  public function setTamano($value) { $this->_tamano = $value; }

  public function getFechaCreacion() { return $this->_fechaCreacion; }
  public function setFechaCreacion($value) { $this->_fechaCreacion = $value; }

  public function getIdUsuario() { return $this->_idUsuario; }
  public function setIdUsuario($value) { $this->_idUsuario = $value; }

  public function getExiste() { return $this->_existe; }
  public function setExiste($value) { $this->_existe = $value; }
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Metodos Publicos">
  /**
   * constructor
   * @author VSR, 22/04/2011
   */
  public function __construct($id = -1) {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Archivo_ObtenerPorId({id});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $id, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      if ($totalRegistros > 0) {
        $row = $arr[0];
        $this->_id = ( is_null($row["Id"]) ) ? -1 : $row["Id"];
        $this->_nombre = ( is_null($row["Nombre"]) ) ? "" : $row["Nombre"];
        $this->_extension = ( is_null($row["Extension"]) ) ? "" : $row["Extension"];
        $this->_contentType = ( is_null($row["ContentType"]) ) ? "" : $row["ContentType"];
        $this->_tamano = ( is_null($row["Tamano"]) ) ? 0 : $row["Tamano"];
        $this->_fechaCreacion = ( is_null($row["FechaCreacion"]) ) ? "" : $row["FechaCreacion"];
        $this->_idUsuario = ( is_null($row["IdUsuario"]) ) ? -1 : $row["IdUsuario"];
        $this->_existe = ($this->_id == -1) ? 0 : 1;
      } else {
        $this->_id = -1;
        $this->_nombre = "";
        $this->_extension = "";
        $this->_contentType = "";
        $this->_tamano = 0;
        $this->_fechaCreacion = "";
        $this->_idUsuario = -1;
        $this->_existe = 0;
      }
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * crea o actualiza un registro
   * @author VSR, 22/04/2011
   */
  public function grabar() {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Archivo_Grabar({id},'{nombre}','{extension}','{contentType}',{tamano},'{fechaCreacion}',{idUsuario});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $this->_id, $sp);
      $sp = str_replace("{nombre}", $this->_nombre, $sp);
      $sp = str_replace("{extension}", $this->_extension, $sp);
      $sp = str_replace("{contentType}", $this->_contentType, $sp);
      $sp = str_replace("{tamano}", $this->_tamano, $sp);
      $sp = str_replace("{fechaCreacion}", $this->_fechaCreacion, $sp);
      $sp = str_replace("{idUsuario}", $this->_idUsuario, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      if ($totalRegistros > 0) {
        $row = $arr[0];
        $this->_id = $row["Id"];
        $this->_existe = 1;
      } else {
        $this->_id = -1;
        $this->_existe = 0;
      }
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * elimina un registro
   * @author VSR, 22/04/2011
   */
  public function eliminar() {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Archivo_Eliminar({id});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $this->_id, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      $this->_id = -1;
      $this->_existe = 0;
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * destructor
   * @author VSR, 22/04/2011
   */
  public function  __destruct() {
   // destruye el objeto
  }
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Metodos Compartidos">
  /**
   * verifica si un archivo existe en disco
   * @param <type> $ruta
   * @return boolean
   * @author VSR, 01/01/2011
   */
  public static function existeArchivo($ruta) {
    $existe = false;
    try {
      if (file_exists($ruta)) {
        $existe = true;
      } else {
        $existe = false;
      }
    } catch (Exception $e) {
      $existe = false;
    }
    return $existe;
  }

  /**
   * determina si un directorio existe en disco
   * @param <type> $dir
   * @return <type> 
   * @author VSR, 22/04/2011
   */
  public static function existeDirectorio($dir) {
    $existe = false;
    try {
      $existe = is_dir($dir);
    } catch (Exception $e) {
      $existe = false;
    }
    return $existe;
  }

  /**
   * crea un directorio en disco
   * @param <type> $dir
   * @author VSR, 22/04/2011
   */
  public static function crearDirectorio($dir) {
    if(!self::existeDirectorio($dir)) {
      mkdir($dir,0777,true);
    }
  }

  /**
   * elimina un directorio recursivamente
   * @param <type> $dir
   * @link http://cl.php.net/manual/es/function.rmdir.php
   */
  public static function eliminarDirectorio($dir) {
     if (is_dir($dir)) {
       $objects = scandir($dir);
       foreach ($objects as $object) {
         if ($object != "." && $object != "..") {
           if (filetype($dir."/".$object) == "dir") self::eliminarDirectorio($dir."/".$object); else unlink($dir."/".$object);
         }
       }
       reset($objects);
       rmdir($dir);
     }
   }

  /**
   * elimina un archivo del disco
   * @param <type> $rutaArchivo
   * @author VSR, 22/04/2011
   */
  public static function eliminarArchivoDisco($rutaArchivo) {
    if(file_exists($rutaArchivo)) {
      unlink($rutaArchivo);
    }
  }

  /**
   * reemplaza caracteres especiales en el nombre del archivo
   * @param <type> $nombreArchivo
   * @return <type>
   * @author VSR, 22/04/2011
   */
  public static function reemplazarCaracteresEspeciales($nombreArchivo, $caracterReemplazo = "_") {
    $nuevoNombre = "";
    try {
      $nuevoNombre = preg_replace('/[^\w\._]+/', $caracterReemplazo, $nombreArchivo);
      $nuevoNombre = Utilidades::reemplazarAcento($nuevoNombre);
    } catch (Exception $e) {
      $nuevoNombre = $nombreArchivo;
    }
    return $nuevoNombre;
  }

  /**
   * determina el tipo de archivo
   * @param <type> $contentType
   * @return <type>
   * @author VSR, 29/04/2011
   */
  public static function esTipoArchivo($contentType) {
    $tipo = "";

    if (Utilidades::isNullOrEmpty($contentType)) {
      $tipo = self::TIPO_DESCONOCIDO;
    } else if (Utilidades::startsWith($contentType, "image/")) {
      $tipo = self::TIPO_IMAGEN;
    } else if (Utilidades::startsWith($contentType,"audio/")) {
      $tipo = self::TIPO_AUDIO;
    } else if (Utilidades::startsWith($contentType,"video/")) {
      $tipo = self::TIPO_VIDEO;
    } else if ($contentType == "application/vnd.ms-excel" ||
               $contentType == "application/vnd.ms-powerpoint" ||
               $contentType == "application/msword" ||
               $contentType == "application/x-mspublisher" ||
               $contentType == "application/vnd.ms-project" ||
               $contentType == "application/x-msaccess") {
      $tipo = self::TIPO_OFFICE;
    } else if ($contentType == "application/zip" ||
               $contentType == "application/x-zip" ||
               $contentType == "application/x-zip-compressed") {
      $tipo = self::TIPO_ZIP;
    } else if (Utilidades::startsWith($contentType,"application/")) {
      $tipo = self::TIPO_APLICACION;
    } else if (Utilidades::startsWith($contentType,"text/")) {
      $tipo = self::TIPO_TEXTO;
    } else {
      $tipo = self::TIPO_OTRO;
    }
    return $tipo;
  }

  /**
   * obtiene la extension del archivo
   * @param <type> $nombreArchivo
   * @return string
   * @author VSR, 22/04/2011
   */
  public static function obtenerExtensionArchivo($nombreArchivo) {
    $extension = "";
    try {
      if(!Utilidades::isNullOrEmpty($nombreArchivo)) {
        $ext = strrpos($nombreArchivo, '.');
        $fileName_a = substr($nombreArchivo, 0, $ext);
        $fileName_b = substr($nombreArchivo, $ext);
        $extension = str_replace(".","",$fileName_b);
      }
    } catch (Exception $e) {
      $extension = "";
    }
    return $extension;
  }

  /**
   * graba los datos del archivo en base de datos
   * @param <type> $idUsuario
   * @param <type> $nombre
   * @param <type> $extension
   * @param <type> $contentType
   * @param <type> $tamano
   * @return string
   * @author VSR, 22/04/2011
   */
  public static function grabaEnBaseDatos($idUsuario, $nombre, $extension, $contentType) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Archivo_GrabaEnBaseDatos({idUsuario},'{nombre}','{extension}','{contentType}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{nombre}", $nombre, $sp);
      $sp = str_replace("{extension}", $extension, $sp);
      $sp = str_replace("{contentType}", $contentType, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = null;
    }
    return $retorno;
  }

  /**
   * asocia el archivo al registro seleccionado
   * @param <type> $idArchivo
   * @param <type> $idRegistro
   * @param <type> $entidad
   * @param <type> $tamano
   * @return <type>
   * @author VSR, 22/04/2011
   */
  public static function asociarArchivoConRegistro($idArchivo, $idRegistro, $entidad, $tamano) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Archivo_AsociarArchivoConRegistro({idArchivo},{idRegistro},'{entidad}', {tamano});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idArchivo}", $idArchivo, $sp);
      $sp = str_replace("{idRegistro}", $idRegistro, $sp);
      $sp = str_replace("{entidad}", $entidad, $sp);
      $sp = str_replace("{tamano}", $tamano, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * obtiene listado de archivos dependiendo de la entidad y el id del registro
   * @param <type> $idRegistro
   * @param <type> $entidad
   * @return string
   * @author VSR, 25/04/2011
   */
  public static function obtenerListado($idRegistro, $entidad) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Archivo_ObtenerListado({idRegistro}, '{entidad}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idRegistro}", $idRegistro, $sp);
      $sp = str_replace("{entidad}", $entidad, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp, Bd::MULTI_QUERY);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * elimina un archivo de la base de datos
   * @param <type> $idArchivo
   * @return <type>
   * @author VSR, 27/04/2011
   */
  public static function eliminarArchivoEnBDPorId($idArchivo) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Archivo_EliminarArchivoEnBDPorId({idArchivo});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idArchivo}", $idArchivo, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * actualiza la descripcion ingresada para el archivo
   * @param <type> $idArchivoRegistro
   * @param <type> $descripcion
   * @return <type>
   * @author VSR, 27/04/2011
   */
  public static function actualizarDescripcion($idArchivoRegistro, $descripcion) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Archivo_ActualizarDescripcion({idArchivoRegistro},'{descripcion}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idArchivoRegistro}", $idArchivoRegistro, $sp);
      $sp = str_replace("{descripcion}", $descripcion, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * obtiene el listado de entidades que contienen archivos en el repositorio
   * @param <type> $entidad
   * @return string
   * @author VSR, 01/05/2011
   */
  public static function obtenerListadoEntidadConFiltro($idUsuario, $entidad, $sinEntidad) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Archivo_ObtenerListadoEntidadConFiltro({idUsuario},'{entidad}','{sinEntidad}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{entidad}", $entidad, $sp);
      $sp = str_replace("{sinEntidad}", $sinEntidad, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * obtiene el listado de archivos por entidad
   * @param <type> $idUsuario
   * @param <type> $entidad
   * @param <type> $tipoArchivo
   * @return string
   * @author VSR, 03/05/2011
   */
  public static function obtenerListadoPorEntidad($idUsuario, $entidad, $tipoArchivo, $sinEntidad) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Archivo_ObtenerListadoPorEntidad({idUsuario},'{entidad}','{tipoArchivo}','{sinEntidad}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{entidad}", $entidad, $sp);
      $sp = str_replace("{tipoArchivo}", $tipoArchivo, $sp);
      $sp = str_replace("{sinEntidad}", $sinEntidad, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * replica los datos de un archivo existente
   * @param <type> $idUsuario
   * @param <type> $idArchivo
   * @param <type> $idRegistro
   * @return string 
   * @author VSR, 11/04/2012
   */
  public static function replicarDatos($idUsuario, $idArchivo, $idRegistro) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Archivo_ReplicarDatos({idUsuario},{idArchivo},{idRegistro});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{idArchivo}", $idArchivo, $sp);
      $sp = str_replace("{idRegistro}", $idRegistro, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }


//</editor-fold>

}
?>

